{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:53.183076Z",
     "start_time": "2024-09-20T03:07:52.747712Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import date\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import seaborn as sns\n",
    "plt.rcParams['font.sans-serif'] = 'SimHei'\n",
    "plt.rcParams['axes.unicode_minus'] = False"
   ],
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:53.188920Z",
     "start_time": "2024-09-20T03:07:53.185082Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 用户在2016年1月1日至2016年6月30日之间真实线上线下消费行为，预测用户在2016年7月领取优惠券后15天以内的使用情况。\n",
    "# 预测投放的优惠券是否核销。\n",
    "# 使用优惠券核销预测的平均AUC（ROC曲线下面积）作为评价标准。即对每个优惠券coupon_id单独计算核销预测的AUC值，再对所有优惠券的AUC值求平均作为最终的评价标准\n",
    "\n",
    "# Coupon_id优惠券ID：null表示无优惠券消费，此时Discount_rate和Date_received字段无意义\n",
    "# Discount_rate优惠率：x \\in [0,1]代表折扣率；x:y表示满x减y。单位是元\n",
    "# Distanceuser经常活动的地点离该merchant的最近门店距离是x*500米（如果是连锁店，则取最近的一家门店），x\\in[0,10]；null表示无此信息，0表示低于500米，10表示大于5公里；\n",
    "# Date_received 领取优惠券日期\n",
    "# Date 消费日期：如果Date=null & Coupon_id != null，该记录表示领取优惠券但没有使用，即负样本；如果Date!=null & Coupon_id = null，则表示普通消费日期；如果Date!=null & Coupon_id != null，则表示用优惠券消费日期，即正样本；"
   ],
   "id": "d0e11031481933ff",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:54.431799Z",
     "start_time": "2024-09-20T03:07:53.188920Z"
    }
   },
   "cell_type": "code",
   "source": [
    " # 读取数据\n",
    " # 用户线下消费和优惠券领取行为\n",
    "off_train_data = pd.read_csv('ccf_offline_stage1_train.csv',encoding='utf-8')\n",
    "off_test_data = pd.read_csv('ccf_offline_stage1_test_revised.csv',encoding='utf-8')"
   ],
   "id": "a2541f5907218ef2",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:54.505072Z",
     "start_time": "2024-09-20T03:07:54.431799Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 空值统计\n",
    "off_train_data.isnull().sum()\n",
    "off_test_data.isnull().sum()\n",
    "# off_train_data.duplicated()"
   ],
   "id": "918ebe3765bea3a9",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "User_id              0\n",
       "Merchant_id          0\n",
       "Coupon_id            0\n",
       "Discount_rate        0\n",
       "Distance         12064\n",
       "Date_received        0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:54.951164Z",
     "start_time": "2024-09-20T03:07:54.505072Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 查缺补漏\n",
    "# 填充缺失值\n",
    "off_train_data = off_train_data.fillna('null')\n",
    "off_test_data = off_test_data.fillna('null')"
   ],
   "id": "a33ee910f5858532",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:56.092112Z",
     "start_time": "2024-09-20T03:07:54.951164Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 去除重复数据\n",
    "off_test_data.drop_duplicates(inplace=True)\n",
    "off_train_data.drop_duplicates(inplace=True)"
   ],
   "id": "f19227be74af0cfb",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:07:56.103063Z",
     "start_time": "2024-09-20T03:07:56.092112Z"
    }
   },
   "cell_type": "code",
   "source": [
    "off_train_data.info()\n",
    "off_train_data.info()\n",
    "# off_train_data.describe()"
   ],
   "id": "8777074a1fac478f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 1716991 entries, 0 to 1754883\n",
      "Data columns (total 7 columns):\n",
      " #   Column         Dtype \n",
      "---  ------         ----- \n",
      " 0   User_id        int64 \n",
      " 1   Merchant_id    int64 \n",
      " 2   Coupon_id      object\n",
      " 3   Discount_rate  object\n",
      " 4   Distance       object\n",
      " 5   Date_received  object\n",
      " 6   Date           object\n",
      "dtypes: int64(2), object(5)\n",
      "memory usage: 104.8+ MB\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 1716991 entries, 0 to 1754883\n",
      "Data columns (total 7 columns):\n",
      " #   Column         Dtype \n",
      "---  ------         ----- \n",
      " 0   User_id        int64 \n",
      " 1   Merchant_id    int64 \n",
      " 2   Coupon_id      object\n",
      " 3   Discount_rate  object\n",
      " 4   Distance       object\n",
      " 5   Date_received  object\n",
      " 6   Date           object\n",
      "dtypes: int64(2), object(5)\n",
      "memory usage: 104.8+ MB\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:23.700111Z",
     "start_time": "2024-09-20T03:07:56.103063Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 用label列标记分类，label的取值为1表示正样本，0表示负样本，-1表示普通用户\n",
    "# 领取优惠券但没有使用，即负样本\n",
    "# 用优惠券消费日期，即正样本\n",
    "# 没有使用优惠券购买 普通用户\n",
    "def label(row):\n",
    "    if row['Date'] != 'null' and row['Date_received'] != 'null':\n",
    "        if row['Coupon_id'] != 'null':\n",
    "            # 优惠券id不为空，表示使用了优惠券购买\n",
    "            # 计算使用优惠券的日期差值\n",
    "            td = pd.to_datetime(row['Date'], format='%Y%m%d') - \\\n",
    "                 pd.to_datetime(row['Date_received'], format='%Y%m%d')\n",
    "            if td <= pd.Timedelta(15, 'D'):  # 判断使用优惠券是否在15天内\n",
    "                return 1\n",
    "            else:\n",
    "                return 0\n",
    "        else:\n",
    "            # 其他情况：优惠券id为null，表示没有使用优惠券购买\n",
    "            return 0\n",
    "    if row['Date'] == 'null' and row['Date_received'] != 'null':\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "# 标记label的值达到分类目的\n",
    "off_train_data['label'] = off_train_data.apply(label, axis = 1)\n",
    "off_train_data['label'].value_counts()\n",
    "\n",
    "off_train_data"
   ],
   "id": "d77838f4097f47c6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "         User_id  Merchant_id Coupon_id Discount_rate Distance Date_received  \\\n",
       "0        1439408         2632      null          null      0.0          null   \n",
       "1        1439408         4663   11002.0        150:20      1.0    20160528.0   \n",
       "2        1439408         2632    8591.0          20:1      0.0    20160217.0   \n",
       "3        1439408         2632    1078.0          20:1      0.0    20160319.0   \n",
       "4        1439408         2632    8591.0          20:1      0.0    20160613.0   \n",
       "...          ...          ...       ...           ...      ...           ...   \n",
       "1754879   212662         3532      null          null      1.0          null   \n",
       "1754880   212662         3021    3739.0          30:1      6.0    20160508.0   \n",
       "1754881   212662         2934      null          null      2.0          null   \n",
       "1754882   752472         7113    1633.0         50:10      6.0    20160613.0   \n",
       "1754883   752472         3621    2705.0          20:5      0.0    20160523.0   \n",
       "\n",
       "               Date  label  \n",
       "0        20160217.0     -1  \n",
       "1              null      0  \n",
       "2              null      0  \n",
       "3              null      0  \n",
       "4              null      0  \n",
       "...             ...    ...  \n",
       "1754879  20160322.0     -1  \n",
       "1754880  20160602.0      0  \n",
       "1754881  20160321.0     -1  \n",
       "1754882        null      0  \n",
       "1754883        null      0  \n",
       "\n",
       "[1716991 rows x 8 columns]"
      ],
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>User_id</th>\n",
       "      <th>Merchant_id</th>\n",
       "      <th>Coupon_id</th>\n",
       "      <th>Discount_rate</th>\n",
       "      <th>Distance</th>\n",
       "      <th>Date_received</th>\n",
       "      <th>Date</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>0.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160217.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1439408</td>\n",
       "      <td>4663</td>\n",
       "      <td>11002.0</td>\n",
       "      <td>150:20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>20160528.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>8591.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160217.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>1078.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160319.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1439408</td>\n",
       "      <td>2632</td>\n",
       "      <td>8591.0</td>\n",
       "      <td>20:1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160613.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754879</th>\n",
       "      <td>212662</td>\n",
       "      <td>3532</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>1.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160322.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754880</th>\n",
       "      <td>212662</td>\n",
       "      <td>3021</td>\n",
       "      <td>3739.0</td>\n",
       "      <td>30:1</td>\n",
       "      <td>6.0</td>\n",
       "      <td>20160508.0</td>\n",
       "      <td>20160602.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754881</th>\n",
       "      <td>212662</td>\n",
       "      <td>2934</td>\n",
       "      <td>null</td>\n",
       "      <td>null</td>\n",
       "      <td>2.0</td>\n",
       "      <td>null</td>\n",
       "      <td>20160321.0</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754882</th>\n",
       "      <td>752472</td>\n",
       "      <td>7113</td>\n",
       "      <td>1633.0</td>\n",
       "      <td>50:10</td>\n",
       "      <td>6.0</td>\n",
       "      <td>20160613.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1754883</th>\n",
       "      <td>752472</td>\n",
       "      <td>3621</td>\n",
       "      <td>2705.0</td>\n",
       "      <td>20:5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20160523.0</td>\n",
       "      <td>null</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1716991 rows × 8 columns</p>\n",
       "</div>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:23.982137Z",
     "start_time": "2024-09-20T03:08:23.700111Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 随机抽样，按照正负样例1：1\n",
    "# 对不平衡的二分类数据进行随机抽样，以实现正负样本的均衡\n",
    "# 切片\n",
    "# X 提取特征数据，不包括标签列。\n",
    "# y 提取标签数据，只包括标签列。\n",
    "# X = off_train_data.loc[:,off_train_data.columns != 'label']  # 数据\n",
    "# y = off_train_data.loc[:,off_train_data.columns == 'label']  # 标签\n",
    "# 获取类1标签的长度\n",
    "count_one_Class = len(off_train_data[off_train_data['label'] == 1])\n",
    "# 获取两类标签的索引\n",
    "one_Class_index = off_train_data[off_train_data['label'] == 1].index\n",
    "zero_Class_index = off_train_data[off_train_data['label'] == 0].index\n",
    "# 随机选择相同数目的索引\n",
    "np.random.seed(25)  # 定义随机种子\n",
    "# 使用 np.random.choice 从标签为0的样本中随机选择与标签为1样本数量相同的样本（random_zero_index）。replace=True 允许重复抽样。\n",
    "random_zero_index = np.array(np.random.choice(zero_Class_index,count_one_Class,replace=True))\n",
    "# 合并模型样本索引\n",
    "sample = np.concatenate([one_Class_index,random_zero_index])\n",
    "# 按照索引获取行\n",
    "off_train_data = off_train_data.loc[sample,:]\n",
    "# 打印结果对比\n",
    "print('label为1的数目：', len(one_Class_index))\n",
    "print('label为0的数目：', len(zero_Class_index))\n",
    "print('总数：', len(one_Class_index) + len(zero_Class_index))\n",
    "print('抽样label为1的数目：', len(one_Class_index))\n",
    "print('随机抽取label为0的数目：', len(random_zero_index))\n",
    "print('抽样总数：', len(one_Class_index) + len(random_zero_index))\n",
    "print('总样本形状：', off_train_data.shape)"
   ],
   "id": "f6ef8b774e88cd",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label为1的数目： 62153\n",
      "label为0的数目： 953236\n",
      "总数： 1015389\n",
      "抽样label为1的数目： 62153\n",
      "随机抽取label为0的数目： 62153\n",
      "抽样总数： 124306\n",
      "总样本形状： (124306, 8)\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:23.987442Z",
     "start_time": "2024-09-20T03:08:23.982137Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# EDA（Exploratory Data Analysis，探索性数据分析）是数据分析过程中的一个重要步骤，旨在通过可视化和总结性统计分析，深入理解数据的特征和结构。其主要目的包括：\n",
    "# \n",
    "# 数据理解：帮助分析师了解数据的基本性质，如分布、趋势和模式。\n",
    "# \n",
    "# 数据清洗：识别缺失值、异常值和重复数据，为后续分析做好准备。\n",
    "# \n",
    "# 特征分析：探究不同变量之间的关系，发现潜在的相关性或因果关系。\n",
    "# \n",
    "# 可视化：使用各种图表（如直方图、箱体图、散点图等）直观展示数据特征，便于交流和解释。\n",
    "# \n",
    "# 假设生成：为后续建模和分析提供依据，提出新的假设或问题。\n",
    "# \n",
    "# EDA 的常用步骤：\n",
    "# 数据加载和查看：检查数据的基本信息和结构。\n",
    "# 数据描述性统计：计算均值、标准差、四分位数等指标。\n",
    "# 缺失值和异常值处理：识别并处理缺失数据和离群点。\n",
    "# 数据可视化：创建多种图表展示数据特征和分布。\n",
    "# 变量间关系分析：分析变量之间的相关性和交互作用。\n",
    "# 通过 EDA，分析师能够更好地为建模做准备，提高分析结果的有效性和可靠性。"
   ],
   "id": "3690c6937b22f209",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:24.782626Z",
     "start_time": "2024-09-20T03:08:23.987442Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 探索性分析EDA\n",
    "# 据探索通常被视为特征工程的一个重要组成部分。通过数据探索，你可以了解数据的分布、缺失值、异常值等，从而为特征选择和创建新特征提供基础。这些发现帮助你更有效地进行特征工程，提升模型性能。\n",
    "off_train_data.value_counts()\n",
    "# 变换距离的类型，缺失值替换为-1\n",
    "off_train_data['Distance'] = off_train_data['Distance'].replace('null', -1).astype(int)\n",
    "off_test_data['Distance'] = off_test_data['Distance'].replace('null', -1).astype(int)\n",
    "print('查看缺失值结果：\\n',off_train_data.isnull().sum())\n",
    "# 描述性统计分析\n",
    "description = off_train_data.describe()\n",
    "# 依次计算极差值、变异系数、四分位数间距\n",
    "# 衡量数据集中分布范围\n",
    "description.loc['range'] = description.loc['max'] - description.loc['min']\n",
    "# 变异系数是标准差与均值的比值，反映数据相对波动性；\n",
    "description.loc['var'] = description.loc['std'] / description.loc['mean']\n",
    "# 上四分位数（75%）与下四分位数（25%）之间的差。这一指标用于衡量数据的集中程度和离散程度，尤其是在数据存在极端值时。\n",
    "description.loc['dis'] = description.loc['75%'] - description.loc['25%']\n",
    "print('描述性统计结果：\\n',np.round(description, 2))  # 保留两位小数\n",
    "\n",
    "# 距离箱型图\n",
    "off_train_data['Distance'].isnull().sum()\n",
    "off_test_data['Distance'].isnull().sum()\n",
    "D1 = np.array(off_train_data['Distance'].values)\n",
    "D2 = np.array(off_test_data['Distance'].values)\n",
    "plt.boxplot([D1,D2],labels=('off_train_data','off_test_data'))\n",
    "plt.title('距离箱型图')\n",
    "plt.show()\n",
    "# 箱体图：识别分布特征：显示数据的中位数、四分位数以及范围，有助于理解数据的集中趋势和离散程度。\n",
    "# 发现异常值：通过箱体外的点，容易识别出异常值或离群点。"
   ],
   "id": "fab0083bed2c53c8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "查看缺失值结果：\n",
      " User_id          0\n",
      "Merchant_id      0\n",
      "Coupon_id        0\n",
      "Discount_rate    0\n",
      "Distance         0\n",
      "Date_received    0\n",
      "Date             0\n",
      "label            0\n",
      "dtype: int64\n",
      "描述性统计结果：\n",
      "           User_id  Merchant_id   Distance     label\n",
      "count   124306.00    124306.00  124306.00  124306.0\n",
      "mean   3693787.05      4075.27       1.87       0.5\n",
      "std    2125191.23      2473.48       3.36       0.5\n",
      "min        236.00         3.00      -1.00       0.0\n",
      "25%    1849676.50      1941.00       0.00       0.0\n",
      "50%    3697501.00      3621.00       0.00       0.5\n",
      "75%    5540370.25      6434.00       2.00       1.0\n",
      "max    7360967.00      8856.00      10.00       1.0\n",
      "range  7360731.00      8853.00      11.00       1.0\n",
      "var          0.58         0.61       1.80       1.0\n",
      "dis    3690693.75      4493.00       2.00       1.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:25.394491Z",
     "start_time": "2024-09-20T03:08:24.782626Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 属性构造\n",
    "# 定义函数处理折扣率\n",
    "def convertRate(row):\n",
    "    if row == 'null':\n",
    "        return 1.0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return 1.0 - float(rows[1]) / float(rows[0])\n",
    "    else:\n",
    "        return float(row)\n",
    "# 定义函数处理折扣率类型\n",
    "def getDiscountType(row):\n",
    "    if row == -1:\n",
    "        return -1\n",
    "    elif ':' in row:\n",
    "        # 满多少减多少\n",
    "        return 1\n",
    "    else:\n",
    "        # 折扣率\n",
    "        return 0\n",
    "# 定义函数处理满减类型的折扣优惠券\n",
    "def Man_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[0])\n",
    "    else:\n",
    "        return 0\n",
    "def Jian_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[1])\n",
    "    else:\n",
    "        return 0\n",
    "# 调用函数构建跟折扣率相关的四个特征属性\n",
    "off_train_data['Dis_rate'] = off_train_data['Discount_rate'].apply(convertRate)\n",
    "off_train_data['Discount_type'] = off_train_data['Discount_rate'].apply(getDiscountType)\n",
    "off_train_data['Discount_man'] = off_train_data['Discount_rate'].apply(Man_Rate)\n",
    "off_train_data['Discount_jian'] = off_train_data['Discount_rate'].apply(Jian_Rate)\n",
    "off_test_data['Dis_rate'] = off_test_data['Discount_rate'].apply(convertRate)\n",
    "off_test_data['Discount_type'] = off_test_data['Discount_rate'].apply(getDiscountType)\n",
    "off_test_data['Discount_man'] = off_test_data['Discount_rate'].apply(Man_Rate)\n",
    "off_test_data['Discount_jian'] = off_test_data['Discount_rate'].apply(Jian_Rate)"
   ],
   "id": "d92492fc801c6485",
   "outputs": [],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:25.514837Z",
     "start_time": "2024-09-20T03:08:25.394491Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 根据label标签来提取正、负样本的全部数据\n",
    "data = off_train_data[off_train_data['label'] != -1]\n",
    "data = data.fillna(-1)\n",
    "data['label'].value_counts()"
   ],
   "id": "8ab509acbed5a91a",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "label\n",
       "1    62153\n",
       "0    62153\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:25.947088Z",
     "start_time": "2024-09-20T03:08:25.514837Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 获取领券日期是星期几，并且构建成特征\n",
    "def getWeekday(row):\n",
    "    if row == 'null':\n",
    "        return row\n",
    "    else:\n",
    "        return date(int(row[0:4]),int(row[4:6]),int(row[6:8])).weekday()+1\n",
    " \n",
    "data['Weekday'] = data['Date_received'].astype(str).apply(getWeekday)\n",
    "off_test_data['Weekday'] = off_test_data['Date_received'].astype(str).apply(getWeekday)\n",
    "# 周六日为类型1，其他为0\n",
    "data['Is_weekend'] = data['Weekday'].apply(lambda x: 1 if x in [6,7] else 0)\n",
    "off_test_data['Is_weekend'] = off_test_data['Weekday'].apply(lambda x: 1 if x in [6,7] else 0)\n",
    "# 跟星期相关的独热编码\n",
    "def One_hot(df):\n",
    "    weekdaycols = ['weekday' + str(i) for i in range(1,8)]\n",
    "    tmpdf = pd.get_dummies(df['Weekday'].replace('null', np.nan))\n",
    "    tmpdf.columns = weekdaycols\n",
    "    df[weekdaycols] = tmpdf\n",
    "    return df\n",
    "data = One_hot(data)\n",
    "off_test_data = One_hot(off_test_data)"
   ],
   "id": "fbb381921ab48c08",
   "outputs": [],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:08:30.474428Z",
     "start_time": "2024-09-20T03:08:25.947088Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义函数得到另外相关的三个特征属性\n",
    "def func(data):\n",
    "    # 提取用户使用的优惠券的数量\n",
    "    f = data[['User_id', 'Coupon_id']]\n",
    "    f['rec_coupon'] = 1\n",
    "    f = f.groupby(['User_id']).agg('sum').reset_index()\n",
    " \n",
    "    # 全部优惠券的数目\n",
    "    f1 = data[['Coupon_id']]\n",
    "    l1 = len(f1)\n",
    "    f1['Number_coupon'] = 1\n",
    "    f1 = f1.groupby(['Coupon_id']).agg('sum').reset_index()\n",
    "    # 优惠券的流行度：每一种优惠券占全部优惠券的比例\n",
    "    f1['Coupon_popu'] = f1['Number_coupon']/l1\n",
    " \n",
    "    # 提取用户和商家\n",
    "    f2 = data[['User_id','Merchant_id']]\n",
    "    l2 = len(f2)\n",
    "    # 提取顾客去商家的数量\n",
    "    f2['Number_merchant'] = 1\n",
    "    f2 = f2.groupby(['Merchant_id']).agg('sum').reset_index()\n",
    "    # 商家的受欢迎度：商家的顾客（用户）占全部商家的顾客（用户）的比例\n",
    "    f2['Merchant_popu'] = f2['Number_merchant']/l2\n",
    " \n",
    "    # 合并特征属性\n",
    "    d0 = pd.merge(data, f[['User_id','rec_coupon']], on='User_id')\n",
    "    d1 = pd.merge(d0,f1[['Coupon_id','Coupon_popu']],on='Coupon_id')\n",
    "    d2 = pd.merge(d1,f2[['Merchant_id','Merchant_popu']],on=['Merchant_id'])\n",
    "    return d2\n",
    "# 调用以上函数构建相关的三个特征属性\n",
    "new_data = func(data)\n",
    "new_test_data = func(off_test_data)\n",
    "# 定义函数得到跟距离相关的特征属性\n",
    "def Get_mer_dis(new_data):\n",
    "    # 查看距离的类别数量\n",
    "    new_data['Distance'].value_counts()\n",
    "    # 提取用户-商家距离的数据集\n",
    "    md1 = new_data[new_data.Coupon_id != 'null'][['Merchant_id', 'Distance']]\n",
    "    md1.replace('null', -1, inplace=True)\n",
    "    md1.replace(-1, np.nan, inplace=True)\n",
    "    # 用户-商家的距离最小值\n",
    "    md2 = md1.groupby('Merchant_id').agg('min').reset_index()\n",
    "    md2.rename(columns={'Distance': 'merchant_min_distance'}, inplace=True)\n",
    "    # 用户-商家的距离最大值\n",
    "    md3 = md1.groupby('Merchant_id').agg('max').reset_index()\n",
    "    md3.rename(columns={'Distance': 'merchant_max_distance'}, inplace=True)\n",
    "    # 用户-商品的距离平均值\n",
    "    md4 = md1.groupby('Merchant_id').agg('mean').reset_index()\n",
    "    md4.rename(columns={'Distance': 'merchant_mean_distance'}, inplace=True)\n",
    "    # 用户-离商品的距离中位值\n",
    "    md5 = md1.groupby('Merchant_id').agg('median').reset_index()\n",
    "    md5.rename(columns={'Distance': 'merchant_median_distance'}, inplace=True)\n",
    "    # 将所有特征合并在一起\n",
    "    merchant_feature = pd.merge(md2, md3, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md4, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md5, on='Merchant_id', how='left')\n",
    "    new_data = pd.merge(new_data,merchant_feature,on='Merchant_id',how='left')\n",
    "    return new_data\n",
    "# 调用上边函数构建距离相关的特征属性\n",
    "new_data = Get_mer_dis(new_data)\n",
    "new_test_data = Get_mer_dis(new_test_data)\n",
    "# 距离柱状图\n",
    "x = np.arange(-1,11)\n",
    "dis1 = np.array(new_data['Distance'].value_counts().sort_index())\n",
    "dis2 = np.array(new_test_data['Distance'].value_counts().sort_index())\n",
    "plt.bar(x,dis1,tick_label=x, label='off_train_data', width=0.3)\n",
    "plt.bar(x+0.3,dis2,label='off_test_data',width=0.3)\n",
    "plt.xlabel('距离')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "# 定义变换距离类型的函数\n",
    "def get_distance_type(row):\n",
    "    # 距离未知\n",
    "    if row == -1:\n",
    "        return -1\n",
    "    # 1千米内\n",
    "    elif row >= 0 and row <= 2:\n",
    "        return 0\n",
    "    # 1.5-2.5千米内\n",
    "    elif row >= 3 and row <= 5:\n",
    "        return 1\n",
    "    # 3-4.5千米内\n",
    "    elif row >= 6 and row <= 9:\n",
    "        return 2\n",
    "    # 5千米\n",
    "    elif row == 10:\n",
    "        return 3\n",
    "# 构建距离类型的特征属性\n",
    "new_data['Distance_type'] = new_data['Distance'].apply(get_distance_type)\n",
    "new_test_data['Distance_type'] = new_test_data['Distance'].apply(get_distance_type)\n",
    "# 新距离类型分布情况\n",
    "new_data['Distance_type'].value_counts()\n",
    "new_test_data['Distance_type'].value_counts()\n",
    "'''\n",
    " 0    84309\n",
    "-1    13858\n",
    " 3    13321\n",
    " 1    11194\n",
    " 2     6108\n",
    "Name: Distance_type, dtype: int64\n",
    "'''\n",
    "# 距离柱状图\n",
    "x1 = np.arange(-1,4)\n",
    "dis_type1 = np.array(new_data['Distance_type'].value_counts().sort_index())\n",
    "dis_type2 = np.array(new_test_data['Distance_type'].value_counts().sort_index())\n",
    "plt.bar(x1,dis_type1,tick_label=x1, label='off_train_data', width=0.3)\n",
    "plt.bar(x1+0.3,dis_type2,label='off_test_data',width=0.3)\n",
    "plt.xlabel('距离类型')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离类型计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "# 跟距离相关的独热编码\n",
    "def Get_dis_hot(df):\n",
    "    discols = ['Distance' + str(i) for i in range(-1,11)]\n",
    "    tmpdf = pd.get_dummies(df['Distance'].replace('null', np.nan))\n",
    "    tmpdf.columns = discols\n",
    "    df[discols] = tmpdf\n",
    "    return df\n",
    "new_data = Get_dis_hot(new_data)\n",
    "new_test_data = Get_dis_hot(new_test_data)\n",
    "# 集成新的数据集后，对缺失值处理\n",
    "new_data = new_data.fillna(-1)\n",
    "new_test_data = new_test_data.fillna(-1)\n",
    "new_data.isnull().sum()\n",
    "new_test_data.isnull().sum()\n",
    "# 再次保存最终文件，方便下次直接读取进行预测操作\n",
    "new_data.to_csv('./final_new_data.csv')\n",
    "new_test_data.to_csv('./final_new_test_data.csv')\n",
    "# 读取最终保存的文件\n",
    "new_data = pd.read_csv('./final_new_data.csv',index_col=0)\n",
    "new_test_data = pd.read_csv('./final_new_test_data.csv',index_col=0)"
   ],
   "id": "8f76436f86eee17f",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f['rec_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:11: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f1['Number_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f2['Number_merchant'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f['rec_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:11: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f1['Number_coupon'] = 1\n",
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\1028807132.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  f2['Number_merchant'] = 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:09:03.829471Z",
     "start_time": "2024-09-20T03:09:03.665754Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 查看属性特征\n",
    "new_data.columns\n",
    "new_test_data.columns\n",
    "# 选取要预测的特征\n",
    "features = ['Dis_rate','Discount_type','Discount_man', 'Discount_jian',\n",
    "            'Distance','Distance_type','Distance-1', 'Distance0',\n",
    "            'Distance1', 'Distance2', 'Distance3', 'Distance4', 'Distance5',\n",
    "            'Distance6', 'Distance7', 'Distance8', 'Distance9', 'Distance10',\n",
    "            ]\n",
    "# 提取指定特征属性的数据集，并且划分为训练集和验证集\n",
    "X = new_data[features]\n",
    "y = new_data['label']\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,stratify=y)\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import roc_auc_score\n",
    "# 初始化决策树分类器\n",
    "classifier = DecisionTreeClassifier()\n",
    "# 训练模型\n",
    "classifier.fit(X_train, y_train)\n",
    "# 预测概率\n",
    "y_pred_proba = classifier.predict_proba(X_test)[:, 1]\n",
    "# 计算 AUC\n",
    "auc = roc_auc_score(y_test, y_pred_proba)\n",
    "auc"
   ],
   "id": "bd4550c519a56855",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7828672724084521"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:09:18.974035Z",
     "start_time": "2024-09-20T03:09:16.938372Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制 ROC曲线\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "# fpr假正率，tpr召回率，thresholds阈值，pos_label（设置正样本值）默认为None（标签数据为二分类的情况）\n",
    "fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred_proba, pos_label=1)\n",
    "roc_auc = metrics.auc(fpr, tpr)  # auc为Roc曲线下的面积\n",
    "plt.plot(fpr, tpr, 'r')  # 绘制ROC曲线\n",
    "axline = np.array([0.,0.2,0.4,0.6,0.8,1.0])  # 斜线参考线坐标\n",
    "plt.plot(axline,axline,'gray',linestyle='--',alpha=0.5)\n",
    "plt.grid(b=True,axis='both',alpha=0.3)  # 显示网格\n",
    "plt.xlim([-0.05, 1.05])  # 设置x轴刻度范围\n",
    "plt.ylim([-0.05, 1.05])  # 设置y轴刻度范围\n",
    "plt.xlabel('FPR')  # x轴是False Positive Rate\n",
    "plt.ylabel('TPR')  # y轴是True Positive Rate\n",
    "plt.title('AUC = %0.2f' % roc_auc)\n",
    "plt.show()"
   ],
   "id": "720cb2a66a6984fd",
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "keyword grid_b is not recognized; valid keywords are ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', 'grid_agg_filter', 'grid_alpha', 'grid_animated', 'grid_antialiased', 'grid_clip_box', 'grid_clip_on', 'grid_clip_path', 'grid_color', 'grid_dash_capstyle', 'grid_dash_joinstyle', 'grid_dashes', 'grid_data', 'grid_drawstyle', 'grid_figure', 'grid_fillstyle', 'grid_gapcolor', 'grid_gid', 'grid_in_layout', 'grid_label', 'grid_linestyle', 'grid_linewidth', 'grid_marker', 'grid_markeredgecolor', 'grid_markeredgewidth', 'grid_markerfacecolor', 'grid_markerfacecoloralt', 'grid_markersize', 'grid_markevery', 'grid_mouseover', 'grid_path_effects', 'grid_picker', 'grid_pickradius', 'grid_rasterized', 'grid_sketch_params', 'grid_snap', 'grid_solid_capstyle', 'grid_solid_joinstyle', 'grid_transform', 'grid_url', 'grid_visible', 'grid_xdata', 'grid_ydata', 'grid_zorder', 'grid_aa', 'grid_c', 'grid_ds', 'grid_ls', 'grid_lw', 'grid_mec', 'grid_mew', 'grid_mfc', 'grid_mfcalt', 'grid_ms']",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[22], line 10\u001B[0m\n\u001B[0;32m      8\u001B[0m axline \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39marray([\u001B[38;5;241m0.\u001B[39m,\u001B[38;5;241m0.2\u001B[39m,\u001B[38;5;241m0.4\u001B[39m,\u001B[38;5;241m0.6\u001B[39m,\u001B[38;5;241m0.8\u001B[39m,\u001B[38;5;241m1.0\u001B[39m])  \u001B[38;5;66;03m# 斜线参考线坐标\u001B[39;00m\n\u001B[0;32m      9\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(axline,axline,\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgray\u001B[39m\u001B[38;5;124m'\u001B[39m,linestyle\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m--\u001B[39m\u001B[38;5;124m'\u001B[39m,alpha\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.5\u001B[39m)\n\u001B[1;32m---> 10\u001B[0m plt\u001B[38;5;241m.\u001B[39mgrid(b\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m,axis\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m,alpha\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.3\u001B[39m)  \u001B[38;5;66;03m# 显示网格\u001B[39;00m\n\u001B[0;32m     11\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlim([\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m0.05\u001B[39m, \u001B[38;5;241m1.05\u001B[39m])  \u001B[38;5;66;03m# 设置x轴刻度范围\u001B[39;00m\n\u001B[0;32m     12\u001B[0m plt\u001B[38;5;241m.\u001B[39mylim([\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m0.05\u001B[39m, \u001B[38;5;241m1.05\u001B[39m])  \u001B[38;5;66;03m# 设置y轴刻度范围\u001B[39;00m\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\pyplot.py:3144\u001B[0m, in \u001B[0;36mgrid\u001B[1;34m(visible, which, axis, **kwargs)\u001B[0m\n\u001B[0;32m   3137\u001B[0m \u001B[38;5;129m@_copy_docstring_and_deprecators\u001B[39m(Axes\u001B[38;5;241m.\u001B[39mgrid)\n\u001B[0;32m   3138\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mgrid\u001B[39m(\n\u001B[0;32m   3139\u001B[0m     visible: \u001B[38;5;28mbool\u001B[39m \u001B[38;5;241m|\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m   (...)\u001B[0m\n\u001B[0;32m   3142\u001B[0m     \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs,\n\u001B[0;32m   3143\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m-> 3144\u001B[0m     gca()\u001B[38;5;241m.\u001B[39mgrid(visible\u001B[38;5;241m=\u001B[39mvisible, which\u001B[38;5;241m=\u001B[39mwhich, axis\u001B[38;5;241m=\u001B[39maxis, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axes\\_base.py:3196\u001B[0m, in \u001B[0;36m_AxesBase.grid\u001B[1;34m(self, visible, which, axis, **kwargs)\u001B[0m\n\u001B[0;32m   3194\u001B[0m _api\u001B[38;5;241m.\u001B[39mcheck_in_list([\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mx\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124my\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m], axis\u001B[38;5;241m=\u001B[39maxis)\n\u001B[0;32m   3195\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m axis \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mx\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[1;32m-> 3196\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mxaxis\u001B[38;5;241m.\u001B[39mgrid(visible, which\u001B[38;5;241m=\u001B[39mwhich, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m   3197\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m axis \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124my\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[0;32m   3198\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39myaxis\u001B[38;5;241m.\u001B[39mgrid(visible, which\u001B[38;5;241m=\u001B[39mwhich, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:1697\u001B[0m, in \u001B[0;36mAxis.grid\u001B[1;34m(self, visible, which, **kwargs)\u001B[0m\n\u001B[0;32m   1694\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m which \u001B[38;5;129;01min\u001B[39;00m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m]:\n\u001B[0;32m   1695\u001B[0m     gridkw[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgridOn\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;241m=\u001B[39m (\u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_major_tick_kw[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mgridOn\u001B[39m\u001B[38;5;124m'\u001B[39m]\n\u001B[0;32m   1696\u001B[0m                         \u001B[38;5;28;01mif\u001B[39;00m visible \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;28;01melse\u001B[39;00m visible)\n\u001B[1;32m-> 1697\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mset_tick_params(which\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mgridkw)\n\u001B[0;32m   1698\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mstale \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mTrue\u001B[39;00m\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:958\u001B[0m, in \u001B[0;36mAxis.set_tick_params\u001B[1;34m(self, which, reset, **kwargs)\u001B[0m\n\u001B[0;32m    945\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m    946\u001B[0m \u001B[38;5;124;03mSet appearance parameters for ticks, ticklabels, and gridlines.\u001B[39;00m\n\u001B[0;32m    947\u001B[0m \n\u001B[1;32m   (...)\u001B[0m\n\u001B[0;32m    955\u001B[0m \u001B[38;5;124;03m    gridlines.\u001B[39;00m\n\u001B[0;32m    956\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m    957\u001B[0m _api\u001B[38;5;241m.\u001B[39mcheck_in_list([\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmajor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mminor\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mboth\u001B[39m\u001B[38;5;124m'\u001B[39m], which\u001B[38;5;241m=\u001B[39mwhich)\n\u001B[1;32m--> 958\u001B[0m kwtrans \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_translate_tick_params(kwargs)\n\u001B[0;32m    960\u001B[0m \u001B[38;5;66;03m# the kwargs are stored in self._major/minor_tick_kw so that any\u001B[39;00m\n\u001B[0;32m    961\u001B[0m \u001B[38;5;66;03m# future new ticks will automatically get them\u001B[39;00m\n\u001B[0;32m    962\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m reset:\n",
      "File \u001B[1;32mD:\\Anaconda\\Lib\\site-packages\\matplotlib\\axis.py:1102\u001B[0m, in \u001B[0;36mAxis._translate_tick_params\u001B[1;34m(kw, reverse)\u001B[0m\n\u001B[0;32m   1100\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m key \u001B[38;5;129;01min\u001B[39;00m kw_:\n\u001B[0;32m   1101\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m key \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;129;01min\u001B[39;00m allowed_keys:\n\u001B[1;32m-> 1102\u001B[0m         \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[0;32m   1103\u001B[0m             \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeyword \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m is not recognized; valid keywords are \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m   1104\u001B[0m             \u001B[38;5;241m%\u001B[39m (key, allowed_keys))\n\u001B[0;32m   1105\u001B[0m kwtrans\u001B[38;5;241m.\u001B[39mupdate(kw_)\n\u001B[0;32m   1106\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m kwtrans\n",
      "\u001B[1;31mValueError\u001B[0m: keyword grid_b is not recognized; valid keywords are ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', 'grid_agg_filter', 'grid_alpha', 'grid_animated', 'grid_antialiased', 'grid_clip_box', 'grid_clip_on', 'grid_clip_path', 'grid_color', 'grid_dash_capstyle', 'grid_dash_joinstyle', 'grid_dashes', 'grid_data', 'grid_drawstyle', 'grid_figure', 'grid_fillstyle', 'grid_gapcolor', 'grid_gid', 'grid_in_layout', 'grid_label', 'grid_linestyle', 'grid_linewidth', 'grid_marker', 'grid_markeredgecolor', 'grid_markeredgewidth', 'grid_markerfacecolor', 'grid_markerfacecoloralt', 'grid_markersize', 'grid_markevery', 'grid_mouseover', 'grid_path_effects', 'grid_picker', 'grid_pickradius', 'grid_rasterized', 'grid_sketch_params', 'grid_snap', 'grid_solid_capstyle', 'grid_solid_joinstyle', 'grid_transform', 'grid_url', 'grid_visible', 'grid_xdata', 'grid_ydata', 'grid_zorder', 'grid_aa', 'grid_c', 'grid_ds', 'grid_ls', 'grid_lw', 'grid_mec', 'grid_mew', 'grid_mfc', 'grid_mfcalt', 'grid_ms']"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T03:09:51.559954Z",
     "start_time": "2024-09-20T03:09:51.245979Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# 预测给定的测试集\n",
    "pre_test = new_test_data[features]\n",
    "result = classifier.predict_proba(pre_test)[:,1]\n",
    "test_result = new_test_data[['User_id','Coupon_id','Date_received']]\n",
    "test_result['Probability'] = result\n",
    "# 查看描述性结果\n",
    "test_result['Probability'].describe()\n",
    "test_result.to_csv('./new_sample_submission.csv',index=None,header=None)"
   ],
   "id": "7ec773e9b496b248",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\31838\\AppData\\Local\\Temp\\ipykernel_21408\\918066157.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  test_result['Probability'] = result\n"
     ]
    }
   ],
   "execution_count": 23
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
